/**
 * Config 类 - 负责数据库配置管理
 * 
 * @class Config
 */

import Utils from './Utils';

class Config {
  /**
   * 构造函数
   * @param {Object} options - 配置选项
   * @param {string} options.name - 数据库名称，默认为 'default'
   * @param {string} options.path - 数据库文件路径（可选）
   * @param {string} options.encryptionKey - 加密密钥（可选）
   * @param {boolean} options.inMemory - 是否使用内存数据库，默认为 false
   * @param {number} options.maxSize - 数据库最大大小（可选，单位：MB）
   * @param {boolean} options.readOnly - 是否只读模式，默认为 false
   */
  constructor(options = {}) {
    // 设置默认值
    this.name = options.name || 'default';
    this.inMemory = options.inMemory || false;
    this.encryptionKey = options.encryptionKey || null;
    this.maxSize = options.maxSize || 512; // 默认512MB
    this.readOnly = options.readOnly || false;
    
    // 设置数据库路径
    if (options.path) {
      this.path = options.path;
    } else if (!this.inMemory) {
      // 使用默认路径
      this.path = Utils.getDefaultDatabasePath(this.name);
    } else {
      // 内存数据库不需要路径
      this.path = null;
    }
    
    // 验证配置
    this._validate();
  }
  
  /**
   * 验证配置
   * @private
   */
  _validate() {
    // 验证数据库名称
    if (!this.name || typeof this.name !== 'string') {
      throw new Error('Database name must be a non-empty string');
    }
    
    // 验证加密密钥
    if (this.encryptionKey && typeof this.encryptionKey !== 'string') {
      throw new Error('Encryption key must be a string');
    }
    
    // 验证最大大小
    if (this.maxSize && (typeof this.maxSize !== 'number' || this.maxSize <= 0)) {
      throw new Error('Max size must be a positive number');
    }
    
    // 验证路径（如果不是内存数据库）
    if (!this.inMemory && (!this.path || typeof this.path !== 'string')) {
      throw new Error('Database path must be a non-empty string for disk-based databases');
    }
  }
  
  /**
   * 克隆配置对象
   * @returns {Config} 克隆后的配置对象
   */
  clone() {
    return new Config({
      name: this.name,
      path: this.path,
      encryptionKey: this.encryptionKey,
      inMemory: this.inMemory,
      maxSize: this.maxSize,
      readOnly: this.readOnly
    });
  }
  
  /**
   * 获取配置的JSON表示
   * @returns {Object} JSON对象
   */
  toJSON() {
    return {
      name: this.name,
      path: this.path,
      inMemory: this.inMemory,
      maxSize: this.maxSize,
      readOnly: this.readOnly
      // 不包含encryptionKey以保护安全
    };
  }
  
  /**
   * 获取默认配置
   * @static
   * @returns {Config} 默认配置对象
   */
  static getDefault() {
    return new Config();
  }
  
  /**
   * 从JSON创建配置对象
   * @static
   * @param {Object} json - JSON对象
   * @returns {Config} 配置对象
   */
  static fromJSON(json) {
    return new Config({
      name: json.name,
      path: json.path,
      encryptionKey: json.encryptionKey,
      inMemory: json.inMemory,
      maxSize: json.maxSize,
      readOnly: json.readOnly
    });
  }
}

export default Config;